home *** CD-ROM | disk | FTP | other *** search
/ Ham Radio 2000 / Ham Radio 2000.iso / ham2000 / misc / dspice0s / diode.c < prev    next >
C/C++ Source or Header  |  1992-11-21  |  17KB  |  537 lines
  1. /* diode.f -- translated by f2c (version of 3 February 1990  3:36:42).
  2.    You must link the resulting object file with the libraries:
  3.     -lF77 -lI77 -lm -lc   (in that order)
  4. */
  5.  
  6. #include "f2c.h"
  7.  
  8. /* Common Block Declarations */
  9.  
  10. struct {
  11.     integer ielmnt, isbckt, nsbckt, iunsat, nunsat, itemps, numtem, isens, 
  12.         nsens, ifour, nfour, ifield, icode, idelim, icolum, insize, 
  13.         junode, lsbkpt, numbkp, iorder, jmnode, iur, iuc, ilc, ilr, 
  14.         numoff, isr, nmoffc, iseq, iseq1, neqn, nodevs, ndiag, iswap, 
  15.         iequa, macins, lvnim1, lx0, lvn, lynl, lyu, lyl, lx1, lx2, lx3, 
  16.         lx4, lx5, lx6, lx7, ld0, ld1, ltd, imynl, imvn, lcvn, nsnod, 
  17.         nsmat, nsval, icnod, icmat, icval, loutpt, lpol, lzer, irswpf, 
  18.         irswpr, icswpf, icswpr, irpt, jcpt, irowno, jcolno, nttbr, nttar, 
  19.         lvntmp;
  20. } tabinf_;
  21.  
  22. #define tabinf_1 tabinf_
  23.  
  24. struct {
  25.     integer locate[50], jelcnt[50], nunods, ncnods, numnod, nstop, nut, nlt, 
  26.         nxtrm, ndist, ntlin, ibr, numvs, numalt, numcyc;
  27. } cirdat_;
  28.  
  29. #define cirdat_1 cirdat_
  30.  
  31. struct {
  32.     doublereal omega, time, delta, delold[7], ag[7], vt, xni, egfet, xmu, 
  33.         sfactr;
  34.     integer mode, modedc, icalc, initf, method, iord, maxord, noncon, iterno, 
  35.         itemno, nosolv, modac, ipiv, ivmflg, ipostp, iscrch, iofile;
  36. } status_;
  37.  
  38. #define status_1 status_
  39.  
  40. struct {
  41.     doublereal twopi, xlog2, xlog10, root2, rad, boltz, charge, ctok, gmin, 
  42.         reltol, abstol, vntol, trtol, chgtol, eps0, epssil, epsox, pivtol,
  43.          pivrel;
  44. } knstnt_;
  45.  
  46. #define knstnt_1 knstnt_
  47.  
  48. struct {
  49.     doublereal value[200000];
  50. } blank_;
  51.  
  52. #define blank_1 blank_
  53.  
  54. /*<       subroutine diode >*/
  55. /* Subroutine */ int diode_()
  56. {
  57.     /* System generated locals */
  58.     integer i_1;
  59.     doublereal d_1, d_2, d_3;
  60.  
  61.     /* Builtin functions */
  62.     double exp(), log();
  63.  
  64.     /* Local variables */
  65.     static doublereal capd, area, fcpb, cdeq;
  66.     static integer ioff, locm;
  67.     static doublereal csat, sarg;
  68.     static integer locv, loct;
  69.     static doublereal vlim, gspr;
  70.     static integer locy, node1, node2, node3;
  71.     static doublereal czof2, cdhat, delvd, xfact, vcrit, evrev, czero, f1, f2,
  72.          f3, cd, gd;
  73.     extern /* Subroutine */ int intgr8_();
  74.     static doublereal pb;
  75. #define qd ((doublereal *)&blank_1 + 3)
  76.     static integer icheck;
  77.     static doublereal bv, vd, xm;
  78. #define nodplc ((integer *)&blank_1)
  79. #define cvalue ((complex *)&blank_1)
  80.     extern /* Subroutine */ int pnjlim_();
  81.     static doublereal vdtemp;
  82. #define cdo ((doublereal *)&blank_1 + 1)
  83. #define cqd ((doublereal *)&blank_1 + 4)
  84. #define gdo ((doublereal *)&blank_1 + 2)
  85.     static doublereal arg, ceq;
  86.     static integer loc;
  87.     static doublereal evd, geq;
  88. #define vdo ((doublereal *)&blank_1)
  89.     static doublereal tau, vte, tol;
  90.  
  91. /*<       implicit double precision (a-h,o-z) >*/
  92.  
  93. /*     this routine processes diodes for dc and transient analyses. */
  94.  
  95. /* spice version 2g.6  sccsid=tabinf 3/15/83 */
  96. /*<       common /tabinf/ ielmnt,isbckt,nsbckt,iunsat,nunsat,itemps,numtem, >*/
  97. /*<      1   isens,nsens,ifour,nfour,ifield,icode,idelim,icolum,insize, >*/
  98. /*<      2   junode,lsbkpt,numbkp,iorder,jmnode,iur,iuc,ilc,ilr,numoff,isr, >*/
  99. /*<      3   nmoffc,iseq,iseq1,neqn,nodevs,ndiag,iswap,iequa,macins,lvnim1, >*/
  100. /*<      4   lx0,lvn,lynl,lyu,lyl,lx1,lx2,lx3,lx4,lx5,lx6,lx7,ld0,ld1,ltd, >*/
  101. /*<      5   imynl,imvn,lcvn,nsnod,nsmat,nsval,icnod,icmat,icval, >*/
  102. /*<      6   loutpt,lpol,lzer,irswpf,irswpr,icswpf,icswpr,irpt,jcpt, >*/
  103. /*<      7   irowno,jcolno,nttbr,nttar,lvntmp >*/
  104. /* spice version 2g.6  sccsid=cirdat 3/15/83 */
  105. /*<       common /cirdat/ locate(50),jelcnt(50),nunods,ncnods,numnod,nstop, >*/
  106. /*<      1   nut,nlt,nxtrm,ndist,ntlin,ibr,numvs,numalt,numcyc >*/
  107. /* spice version 2g.6  sccsid=status 3/15/83 */
  108. /*<       common /status/ omega,time,delta,delold(7),ag(7),vt,xni,egfet, >*/
  109. /*<      1   xmu,sfactr,mode,modedc,icalc,initf,method,iord,maxord,noncon, >*/
  110. /*<      2   iterno,itemno,nosolv,modac,ipiv,ivmflg,ipostp,iscrch,iofile >*/
  111. /* spice version 2g.6  sccsid=knstnt 3/15/83 */
  112. /*<       common /knstnt/ twopi,xlog2,xlog10,root2,rad,boltz,charge,ctok, >*/
  113. /*<      1   gmin,reltol,abstol,vntol,trtol,chgtol,eps0,epssil,epsox, >*/
  114. /*<      2   pivtol,pivrel >*/
  115. /* spice version 2g.6  sccsid=blank 3/15/83 */
  116. /*<       common /blank/ value(200000) >*/
  117. /*<       integer nodplc(64) >*/
  118. /*<       complex cvalue(32) >*/
  119. /*<       equivalence (value(1),nodplc(1),cvalue(1)) >*/
  120.  
  121.  
  122. /*<       dimension vdo(1),cdo(1),gdo(1),qd(1),cqd(1) >*/
  123. /*<       equivalence (vdo(1),value(1)),(cdo(1),value(2)), >*/
  124. /*<      1   (gdo(1),value(3)),(qd(1),value(4)),(cqd(1),value(5)) >*/
  125.  
  126.  
  127. /*<       loc=locate(11) >*/
  128.     loc = cirdat_1.locate[10];
  129. /*<    10 if ((loc.eq.0).or.(nodplc(loc+16).ne.0)) return >*/
  130. L10:
  131.     if (loc == 0 || nodplc[loc + 15] != 0) {
  132.     return 0;
  133.     }
  134. /*<       locv=nodplc(loc+1) >*/
  135.     locv = nodplc[loc];
  136. /*<       node1=nodplc(loc+2) >*/
  137.     node1 = nodplc[loc + 1];
  138. /*<       node2=nodplc(loc+3) >*/
  139.     node2 = nodplc[loc + 2];
  140. /*<       node3=nodplc(loc+4) >*/
  141.     node3 = nodplc[loc + 3];
  142. /*<       locm=nodplc(loc+5) >*/
  143.     locm = nodplc[loc + 4];
  144. /*<       ioff=nodplc(loc+6) >*/
  145.     ioff = nodplc[loc + 5];
  146. /*<       locm=nodplc(locm+1) >*/
  147.     locm = nodplc[locm];
  148. /*<       loct=nodplc(loc+11) >*/
  149.     loct = nodplc[loc + 10];
  150.  
  151. /*  dc model parameters */
  152.  
  153. /*<       area=value(locv+1) >*/
  154.     area = blank_1.value[locv];
  155. /*<       csat=value(locm+1)*area >*/
  156.     csat = blank_1.value[locm] * area;
  157. /*<       gspr=value(locm+2)*area >*/
  158.     gspr = blank_1.value[locm + 1] * area;
  159. /*<       vte=value(locm+3)*vt >*/
  160.     vte = blank_1.value[locm + 2] * status_1.vt;
  161. /*<       bv=value(locm+13) >*/
  162.     bv = blank_1.value[locm + 12];
  163. /*<       vcrit=value(locm+18) >*/
  164.     vcrit = blank_1.value[locm + 17];
  165.  
  166. /*  initialization */
  167.  
  168. /*<       icheck=1 >*/
  169.     icheck = 1;
  170. /*<       go to (100,20,30,50,60,70),initf >*/
  171.     switch (status_1.initf) {
  172.     case 1:  goto L100;
  173.     case 2:  goto L20;
  174.     case 3:  goto L30;
  175.     case 4:  goto L50;
  176.     case 5:  goto L60;
  177.     case 6:  goto L70;
  178.     }
  179. /*<    20 if(mode.ne.1.or.modedc.ne.2.or.nosolv.eq.0) go to 25 >*/
  180. L20:
  181.     if (status_1.mode != 1 || status_1.modedc != 2 || status_1.nosolv == 0) {
  182.     goto L25;
  183.     }
  184. /*<       vd=value(locv+2) >*/
  185.     vd = blank_1.value[locv + 1];
  186. /*<       go to 300 >*/
  187.     goto L300;
  188. /*<    25 if(ioff.ne.0) go to 40 >*/
  189. L25:
  190.     if (ioff != 0) {
  191.     goto L40;
  192.     }
  193. /*<       vd=vcrit >*/
  194.     vd = vcrit;
  195. /*<       go to 300 >*/
  196.     goto L300;
  197. /*<    30 if (ioff.eq.0) go to 100 >*/
  198. L30:
  199.     if (ioff == 0) {
  200.     goto L100;
  201.     }
  202. /*<    40 vd=0.0d0 >*/
  203. L40:
  204.     vd = 0.;
  205. /*<       go to 300 >*/
  206.     goto L300;
  207. /*<    50 vd=vdo(lx0+loct) >*/
  208. L50:
  209.     vd = vdo[tabinf_1.lx0 + loct - 1];
  210. /*<       go to 300 >*/
  211.     goto L300;
  212. /*<    60 vd=vdo(lx1+loct) >*/
  213. L60:
  214.     vd = vdo[tabinf_1.lx1 + loct - 1];
  215. /*<       go to 300 >*/
  216.     goto L300;
  217. /*<    70 xfact=delta/delold(2) >*/
  218. L70:
  219.     xfact = status_1.delta / status_1.delold[1];
  220. /*<       vdo(lx0+loct)=vdo(lx1+loct) >*/
  221.     vdo[tabinf_1.lx0 + loct - 1] = vdo[tabinf_1.lx1 + loct - 1];
  222. /*<       vd=(1.0d0+xfact)*vdo(lx1+loct)-xfact*vdo(lx2+loct) >*/
  223.     vd = (xfact + 1.) * vdo[tabinf_1.lx1 + loct - 1] - xfact * vdo[
  224.         tabinf_1.lx2 + loct - 1];
  225. /*<       cdo(lx0+loct)=cdo(lx1+loct) >*/
  226.     cdo[tabinf_1.lx0 + loct - 1] = cdo[tabinf_1.lx1 + loct - 1];
  227. /*<       gdo(lx0+loct)=gdo(lx1+loct) >*/
  228.     gdo[tabinf_1.lx0 + loct - 1] = gdo[tabinf_1.lx1 + loct - 1];
  229. /*<       go to 110 >*/
  230.     goto L110;
  231.  
  232. /*  compute new nonlinear branch voltage */
  233.  
  234. /*<   100 vd=value(lvnim1+node3)-value(lvnim1+node2) >*/
  235. L100:
  236.     vd = blank_1.value[tabinf_1.lvnim1 + node3 - 1] - blank_1.value[
  237.         tabinf_1.lvnim1 + node2 - 1];
  238. /*<   110 delvd=vd-vdo(lx0+loct) >*/
  239. L110:
  240.     delvd = vd - vdo[tabinf_1.lx0 + loct - 1];
  241. /*<       cdhat=cdo(lx0+loct)+gdo(lx0+loct)*delvd >*/
  242.     cdhat = cdo[tabinf_1.lx0 + loct - 1] + gdo[tabinf_1.lx0 + loct - 1] * 
  243.         delvd;
  244.  
  245. /*  bypass if solution has not changed */
  246.  
  247. /*<       if (initf.eq.6) go to 200 >*/
  248.     if (status_1.initf == 6) {
  249.     goto L200;
  250.     }
  251. /*<       tol=reltol*dmax1(dabs(vd),dabs(vdo(lx0+loct)))+vntol >*/
  252. /* Computing MAX */
  253.     d_2 = abs(vd), d_3 = (d_1 = vdo[tabinf_1.lx0 + loct - 1], abs(d_1));
  254.     tol = knstnt_1.reltol * max(d_3,d_2) + knstnt_1.vntol;
  255. /*<       if (dabs(delvd).ge.tol) go to 200 >*/
  256.     if (abs(delvd) >= tol) {
  257.     goto L200;
  258.     }
  259. /*<       tol=reltol*dmax1(dabs(cdhat),dabs(cdo(lx0+loct)))+abstol >*/
  260. /* Computing MAX */
  261.     d_2 = abs(cdhat), d_3 = (d_1 = cdo[tabinf_1.lx0 + loct - 1], abs(d_1));
  262.     tol = knstnt_1.reltol * max(d_3,d_2) + knstnt_1.abstol;
  263. /*<       if (dabs(cdhat-cdo(lx0+loct)).ge.tol) go to 200 >*/
  264.     if ((d_1 = cdhat - cdo[tabinf_1.lx0 + loct - 1], abs(d_1)) >= tol) {
  265.     goto L200;
  266.     }
  267. /*<       vd=vdo(lx0+loct) >*/
  268.     vd = vdo[tabinf_1.lx0 + loct - 1];
  269. /*<       cd=cdo(lx0+loct) >*/
  270.     cd = cdo[tabinf_1.lx0 + loct - 1];
  271. /*<       gd=gdo(lx0+loct) >*/
  272.     gd = gdo[tabinf_1.lx0 + loct - 1];
  273. /*<       go to 800 >*/
  274.     goto L800;
  275.  
  276. /*  limit new junction voltage */
  277.  
  278. /*<   200 vlim=vte+vte >*/
  279. L200:
  280.     vlim = vte + vte;
  281. /*<       if(bv.eq.0.0d0) go to 205 >*/
  282.     if (bv == 0.) {
  283.     goto L205;
  284.     }
  285. /*<       if (vd.lt.dmin1(0.0d0,-bv+10.0d0*vte)) go to 210 >*/
  286. /* Computing MAX */
  287.     d_1 = 0., d_2 = -bv + vte * 10.;
  288.     if (vd < min(d_2,d_1)) {
  289.     goto L210;
  290.     }
  291. /*<   205 call pnjlim(vd,vdo(lx0+loct),vte,vcrit,icheck) >*/
  292. L205:
  293.     pnjlim_(&vd, &vdo[tabinf_1.lx0 + loct - 1], &vte, &vcrit, &icheck);
  294. /*<       go to 300 >*/
  295.     goto L300;
  296. /*<   210 vdtemp=-(vd+bv) >*/
  297. L210:
  298.     vdtemp = -(vd + bv);
  299. /*<       call pnjlim(vdtemp,-(vdo(lx0+loct)+bv),vte,vcrit,icheck) >*/
  300.     d_1 = -(vdo[tabinf_1.lx0 + loct - 1] + bv);
  301.     pnjlim_(&vdtemp, &d_1, &vte, &vcrit, &icheck);
  302. /*<       vd=-(vdtemp+bv) >*/
  303.     vd = -(vdtemp + bv);
  304.  
  305. /*  compute dc current and derivitives */
  306.  
  307. /*<   300 if (vd.lt.-5.0d0*vte) go to 310 >*/
  308. L300:
  309.     if (vd < vte * -5.) {
  310.     goto L310;
  311.     }
  312. /*<       evd=dexp(vd/vte) >*/
  313.     evd = exp(vd / vte);
  314. /*<       cd=csat*(evd-1.0d0)+gmin*vd >*/
  315.     cd = csat * (evd - 1.) + knstnt_1.gmin * vd;
  316. /*<       gd=csat*evd/vte+gmin >*/
  317.     gd = csat * evd / vte + knstnt_1.gmin;
  318. /*<       go to 330 >*/
  319.     goto L330;
  320. /*<   310 if(bv.eq.0.0d0) go to 315 >*/
  321. L310:
  322.     if (bv == 0.) {
  323.     goto L315;
  324.     }
  325. /*<       if(vd.lt.-bv) go to 320 >*/
  326.     if (vd < -bv) {
  327.     goto L320;
  328.     }
  329. /*<   315 gd=-csat/vd+gmin >*/
  330. L315:
  331.     gd = -csat / vd + knstnt_1.gmin;
  332. /*<       cd=gd*vd >*/
  333.     cd = gd * vd;
  334. /*<       go to 330 >*/
  335.     goto L330;
  336. /*<   320 evrev=dexp(-(bv+vd)/vt) >*/
  337. L320:
  338.     evrev = exp(-(bv + vd) / status_1.vt);
  339. /*<       cd=-csat*(evrev-1.0d0+bv/vt) >*/
  340.     cd = -csat * (evrev - 1. + bv / status_1.vt);
  341. /*<       gd=csat*evrev/vt >*/
  342.     gd = csat * evrev / status_1.vt;
  343. /*<   330 if (mode.ne.1) go to 500 >*/
  344. L330:
  345.     if (status_1.mode != 1) {
  346.     goto L500;
  347.     }
  348. /*<       if ((modedc.eq.2).and.(nosolv.ne.0)) go to 500 >*/
  349.     if (status_1.modedc == 2 && status_1.nosolv != 0) {
  350.     goto L500;
  351.     }
  352. /*<       if (initf.eq.4) go to 500 >*/
  353.     if (status_1.initf == 4) {
  354.     goto L500;
  355.     }
  356. /*<       go to 700 >*/
  357.     goto L700;
  358.  
  359. /*  charge storage elements */
  360.  
  361. /*<   500 tau=value(locm+4) >*/
  362. L500:
  363.     tau = blank_1.value[locm + 3];
  364. /*<       czero=value(locm+5)*area >*/
  365.     czero = blank_1.value[locm + 4] * area;
  366. /*<       pb=value(locm+6) >*/
  367.     pb = blank_1.value[locm + 5];
  368. /*<       xm=value(locm+7) >*/
  369.     xm = blank_1.value[locm + 6];
  370. /*<       fcpb=value(locm+12) >*/
  371.     fcpb = blank_1.value[locm + 11];
  372. /*<       if (vd.ge.fcpb) go to 510 >*/
  373.     if (vd >= fcpb) {
  374.     goto L510;
  375.     }
  376. /*<       arg=1.0d0-vd/pb >*/
  377.     arg = 1. - vd / pb;
  378. /*<       sarg=dexp(-xm*dlog(arg)) >*/
  379.     sarg = exp(-xm * log(arg));
  380. /*<       qd(lx0+loct)=tau*cd+pb*czero*(1.0d0-arg*sarg)/(1.0d0-xm) >*/
  381.     qd[tabinf_1.lx0 + loct - 1] = tau * cd + pb * czero * (1. - arg * sarg) / 
  382.         (1. - xm);
  383. /*<       capd=tau*gd+czero*sarg >*/
  384.     capd = tau * gd + czero * sarg;
  385. /*<       go to 520 >*/
  386.     goto L520;
  387. /*<   510 f1=value(locm+15) >*/
  388. L510:
  389.     f1 = blank_1.value[locm + 14];
  390. /*<       f2=value(locm+16) >*/
  391.     f2 = blank_1.value[locm + 15];
  392. /*<       f3=value(locm+17) >*/
  393.     f3 = blank_1.value[locm + 16];
  394. /*<       czof2=czero/f2 >*/
  395.     czof2 = czero / f2;
  396. /*<       qd(lx0+loct)=tau*cd+czero*f1+czof2*(f3*(vd-fcpb) >*/
  397. /*<      1   +(xm/(pb+pb))*(vd*vd-fcpb*fcpb)) >*/
  398.     qd[tabinf_1.lx0 + loct - 1] = tau * cd + czero * f1 + czof2 * (f3 * (vd - 
  399.         fcpb) + xm / (pb + pb) * (vd * vd - fcpb * fcpb));
  400. /*<       capd=tau*gd+czof2*(f3+xm*vd/pb) >*/
  401.     capd = tau * gd + czof2 * (f3 + xm * vd / pb);
  402.  
  403. /*  store small-signal parameters */
  404.  
  405. /*<   520 if ((mode.eq.1).and.(modedc.eq.2).and.(nosolv.ne.0)) go to 700 >*/
  406. L520:
  407.     if (status_1.mode == 1 && status_1.modedc == 2 && status_1.nosolv != 0) {
  408.     goto L700;
  409.     }
  410. /*<       if (initf.ne.4) go to 600 >*/
  411.     if (status_1.initf != 4) {
  412.     goto L600;
  413.     }
  414. /*<       value(lx0+loct+4)=capd >*/
  415.     blank_1.value[tabinf_1.lx0 + loct + 3] = capd;
  416. /*<       go to 1000 >*/
  417.     goto L1000;
  418.  
  419. /*  transient analysis */
  420.  
  421. /*<   600 if (initf.ne.5) go to 610 >*/
  422. L600:
  423.     if (status_1.initf != 5) {
  424.     goto L610;
  425.     }
  426. /*<       qd(lx1+loct)=qd(lx0+loct) >*/
  427.     qd[tabinf_1.lx1 + loct - 1] = qd[tabinf_1.lx0 + loct - 1];
  428. /*<   610 call intgr8(geq,ceq,capd,loct+3) >*/
  429. L610:
  430.     i_1 = loct + 3;
  431.     intgr8_(&geq, &ceq, &capd, &i_1);
  432. /*<       gd=gd+geq >*/
  433.     gd += geq;
  434. /*<       cd=cd+cqd(lx0+loct) >*/
  435.     cd += cqd[tabinf_1.lx0 + loct - 1];
  436. /*<       if (initf.ne.5) go to 700 >*/
  437.     if (status_1.initf != 5) {
  438.     goto L700;
  439.     }
  440. /*<       cqd(lx1+loct)=cqd(lx0+loct) >*/
  441.     cqd[tabinf_1.lx1 + loct - 1] = cqd[tabinf_1.lx0 + loct - 1];
  442.  
  443. /*  check convergence */
  444.  
  445. /*<   700 if (initf.ne.3) go to 710 >*/
  446. L700:
  447.     if (status_1.initf != 3) {
  448.     goto L710;
  449.     }
  450. /*<       if (ioff.eq.0) go to 710 >*/
  451.     if (ioff == 0) {
  452.     goto L710;
  453.     }
  454. /*<       go to 750 >*/
  455.     goto L750;
  456. /*<   710 if (icheck.eq.1) go to 720 >*/
  457. L710:
  458.     if (icheck == 1) {
  459.     goto L720;
  460.     }
  461. /*<       tol=reltol*dmax1(dabs(cdhat),dabs(cd))+abstol >*/
  462. /* Computing MAX */
  463.     d_1 = abs(cdhat), d_2 = abs(cd);
  464.     tol = knstnt_1.reltol * max(d_2,d_1) + knstnt_1.abstol;
  465. /*<       if (dabs(cdhat-cd).le.tol) go to 750 >*/
  466.     if ((d_1 = cdhat - cd, abs(d_1)) <= tol) {
  467.     goto L750;
  468.     }
  469. /*<   720 noncon=noncon+1 >*/
  470. L720:
  471.     ++status_1.noncon;
  472. /*<   750 vdo(lx0+loct)=vd >*/
  473. L750:
  474.     vdo[tabinf_1.lx0 + loct - 1] = vd;
  475. /*<       cdo(lx0+loct)=cd >*/
  476.     cdo[tabinf_1.lx0 + loct - 1] = cd;
  477. /*<       gdo(lx0+loct)=gd >*/
  478.     gdo[tabinf_1.lx0 + loct - 1] = gd;
  479.  
  480. /*  load current vector */
  481.  
  482. /*<   800 cdeq=cd-gd*vd >*/
  483. L800:
  484.     cdeq = cd - gd * vd;
  485. /*<       value(lvn+node2)=value(lvn+node2)+cdeq >*/
  486.     blank_1.value[tabinf_1.lvn + node2 - 1] += cdeq;
  487. /*<       value(lvn+node3)=value(lvn+node3)-cdeq >*/
  488.     blank_1.value[tabinf_1.lvn + node3 - 1] -= cdeq;
  489.  
  490. /*  load matrix */
  491.  
  492. /*<       locy=lvn+nodplc(loc+13) >*/
  493.     locy = tabinf_1.lvn + nodplc[loc + 12];
  494. /*<       value(locy)=value(locy)+gspr >*/
  495.     blank_1.value[locy - 1] += gspr;
  496. /*<       locy=lvn+nodplc(loc+14) >*/
  497.     locy = tabinf_1.lvn + nodplc[loc + 13];
  498. /*<       value(locy)=value(locy)+gd >*/
  499.     blank_1.value[locy - 1] += gd;
  500. /*<       locy=lvn+nodplc(loc+15) >*/
  501.     locy = tabinf_1.lvn + nodplc[loc + 14];
  502. /*<       value(locy)=value(locy)+gd+gspr >*/
  503.     blank_1.value[locy - 1] = blank_1.value[locy - 1] + gd + gspr;
  504. /*<       locy=lvn+nodplc(loc+7) >*/
  505.     locy = tabinf_1.lvn + nodplc[loc + 6];
  506. /*<       value(locy)=value(locy)-gspr >*/
  507.     blank_1.value[locy - 1] -= gspr;
  508. /*<       locy=lvn+nodplc(loc+8) >*/
  509.     locy = tabinf_1.lvn + nodplc[loc + 7];
  510. /*<       value(locy)=value(locy)-gd >*/
  511.     blank_1.value[locy - 1] -= gd;
  512. /*<       locy=lvn+nodplc(loc+9) >*/
  513.     locy = tabinf_1.lvn + nodplc[loc + 8];
  514. /*<       value(locy)=value(locy)-gspr >*/
  515.     blank_1.value[locy - 1] -= gspr;
  516. /*<       locy=lvn+nodplc(loc+10) >*/
  517.     locy = tabinf_1.lvn + nodplc[loc + 9];
  518. /*<       value(locy)=value(locy)-gd >*/
  519.     blank_1.value[locy - 1] -= gd;
  520. /*<  1000 loc=nodplc(loc) >*/
  521. L1000:
  522.     loc = nodplc[loc - 1];
  523. /*<       go to 10 >*/
  524.     goto L10;
  525. /*<       end >*/
  526. } /* diode_ */
  527.  
  528. #undef vdo
  529. #undef gdo
  530. #undef cqd
  531. #undef cdo
  532. #undef cvalue
  533. #undef nodplc
  534. #undef qd
  535.  
  536.  
  537.